home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / More Source / C⁄C++ / Peter's Final Project / jpeg-5b / jpegint.h < prev    next >
Text File  |  1995-03-10  |  14KB  |  361 lines
  1. /*
  2.  * jpegint.h
  3.  *
  4.  * Copyright (C) 1991-1995, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file provides common declarations for the various JPEG modules.
  9.  * These declarations are considered internal to the JPEG library; most
  10.  * applications using the library shouldn't need to include this file.
  11.  */
  12.  
  13.  
  14. /* Declarations for both compression & decompression */
  15.  
  16. typedef enum {            /* Operating modes for buffer controllers */
  17.     JBUF_PASS_THRU,        /* Plain stripwise operation */
  18.     JBUF_CRANK_SOURCE,    /* Run source subobject, no output expected */
  19.     /* Remaining modes require a full-image buffer to have been created */
  20.     JBUF_SAVE_SOURCE,    /* Run source subobject only, save output */
  21.     JBUF_CRANK_DEST,    /* Run dest subobject only, using saved data */
  22.     JBUF_SAVE_AND_PASS    /* Run both subobjects, save output */
  23. } J_BUF_MODE;
  24.  
  25. /* Values of global_state field */
  26. #define CSTATE_START    100    /* after create_compress */
  27. #define CSTATE_SCANNING    101    /* start_compress done, write_scanlines OK */
  28. #define CSTATE_RAW_OK    102    /* start_compress done, write_raw_data OK */
  29. #define DSTATE_START    200    /* after create_decompress */
  30. #define DSTATE_INHEADER    201    /* read_header initialized but not done */
  31. #define DSTATE_READY    202    /* read_header done, found image */
  32. #define DSTATE_SCANNING    203    /* start_decompress done, read_scanlines OK */
  33. #define DSTATE_RAW_OK    204    /* start_decompress done, read_raw_data OK */
  34. #define DSTATE_STOPPING    205    /* done reading data, looking for EOI */
  35.  
  36.  
  37. /* Declarations for compression modules */
  38.  
  39. /* Master control module */
  40. struct jpeg_comp_master {
  41.   JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
  42.   JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
  43.   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
  44.  
  45.   /* State variables made visible to other modules */
  46.   boolean call_pass_startup;    /* True if pass_startup must be called */
  47.   boolean is_last_pass;        /* True during last pass */
  48. };
  49.  
  50. /* Main buffer control (downsampled-data buffer) */
  51. struct jpeg_c_main_controller {
  52.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
  53.   JMETHOD(void, process_data, (j_compress_ptr cinfo,
  54.                    JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
  55.                    JDIMENSION in_rows_avail));
  56. };
  57.  
  58. /* Compression preprocessing (downsampling input buffer control) */
  59. struct jpeg_c_prep_controller {
  60.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
  61.   JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
  62.                    JSAMPARRAY input_buf,
  63.                    JDIMENSION *in_row_ctr,
  64.                    JDIMENSION in_rows_avail,
  65.                    JSAMPIMAGE output_buf,
  66.                    JDIMENSION *out_row_group_ctr,
  67.                    JDIMENSION out_row_groups_avail));
  68. };
  69.  
  70. /* Coefficient buffer control */
  71. struct jpeg_c_coef_controller {
  72.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
  73.   JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
  74.                    JSAMPIMAGE input_buf));
  75. };
  76.  
  77. /* Colorspace conversion */
  78. struct jpeg_color_converter {
  79.   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
  80.   JMETHOD(void, color_convert, (j_compress_ptr cinfo,
  81.                 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
  82.                 JDIMENSION output_row, int num_rows));
  83. };
  84.  
  85. /* Downsampling */
  86. struct jpeg_downsampler {
  87.   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
  88.   JMETHOD(void, downsample, (j_compress_ptr cinfo,
  89.                  JSAMPIMAGE input_buf, JDIMENSION in_row_index,
  90.                  JSAMPIMAGE output_buf,
  91.                  JDIMENSION out_row_group_index));
  92.  
  93.   boolean need_context_rows;    /* TRUE if need rows above & below */
  94. };
  95.  
  96. /* Forward DCT (also controls coefficient quantization) */
  97. struct jpeg_forward_dct {
  98.   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
  99.   /* perhaps this should be an array??? */
  100.   JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
  101.                   jpeg_component_info * compptr,
  102.                   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
  103.                   JDIMENSION start_row, JDIMENSION start_col,
  104.                   JDIMENSION num_blocks));
  105. };
  106.  
  107. /* Entropy encoding */
  108. struct jpeg_entropy_encoder {
  109.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
  110.   JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
  111.   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
  112. };
  113.  
  114. /* Marker writing */
  115. struct jpeg_marker_writer {
  116.   /* write_any_marker is exported for use by applications */
  117.   /* Probably only COM and APPn markers should be written */
  118.   JMETHOD(void, write_any_marker, (j_compress_ptr cinfo, int marker,
  119.                    const JOCTET *dataptr, unsigned int datalen));
  120.   JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
  121.   JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
  122.   JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
  123.   JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
  124.   JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
  125. };
  126.  
  127.  
  128. /* Declarations for decompression modules */
  129.  
  130. /* Master control module */
  131. struct jpeg_decomp_master {
  132.   JMETHOD(void, prepare_for_pass, (j_decompress_ptr cinfo));
  133.   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
  134.  
  135.   /* State variables made visible to other modules */
  136.   boolean is_last_pass;        /* True during last pass */
  137.   boolean eoi_processed;    /* True if EOI marker already read */
  138. };
  139.  
  140. /* Main buffer control (downsampled-data buffer) */
  141. struct jpeg_d_main_controller {
  142.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  143.   JMETHOD(void, process_data, (j_decompress_ptr cinfo,
  144.                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
  145.                    JDIMENSION out_rows_avail));
  146.   /* During input-only passes, output_buf and out_rows_avail are ignored.
  147.    * out_row_ctr is incremented towards the limit num_chunks.
  148.    */
  149.   JDIMENSION num_chunks;    /* number of chunks to be processed in pass */
  150. };
  151.  
  152. /* Coefficient buffer control */
  153. struct jpeg_d_coef_controller {
  154.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  155.   JMETHOD(boolean, decompress_data, (j_decompress_ptr cinfo,
  156.                      JSAMPIMAGE output_buf));
  157. };
  158.  
  159. /* Decompression postprocessing (color quantization buffer control) */
  160. struct jpeg_d_post_controller {
  161.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  162.   JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
  163.                     JSAMPIMAGE input_buf,
  164.                     JDIMENSION *in_row_group_ctr,
  165.                     JDIMENSION in_row_groups_avail,
  166.                     JSAMPARRAY output_buf,
  167.                     JDIMENSION *out_row_ctr,
  168.                     JDIMENSION out_rows_avail));
  169. };
  170.  
  171. /* Marker reading & parsing */
  172. struct jpeg_marker_reader {
  173.   JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
  174.   /* Read markers until SOS or EOI.
  175.    * Returns same codes as are defined for jpeg_read_header,
  176.    * but HEADER_OK and HEADER_TABLES_ONLY merely indicate which marker type
  177.    * stopped the scan --- further validation is needed to declare file OK.
  178.    */
  179.   JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
  180.   /* Read a restart marker --- exported for use by entropy decoder only */
  181.   jpeg_marker_parser_method read_restart_marker;
  182.   /* Application-overridable marker processing methods */
  183.   jpeg_marker_parser_method process_COM;
  184.   jpeg_marker_parser_method process_APPn[16];
  185.  
  186.   /* State of marker reader --- nominally internal, but applications
  187.    * supplying COM or APPn handlers might like to know the state.
  188.    */
  189.   boolean saw_SOI;        /* found SOI? */
  190.   boolean saw_SOF;        /* found SOF? */
  191.   int next_restart_num;        /* next restart number expected (0-7) */
  192.   unsigned int discarded_bytes;    /* # of bytes skipped looking for a marker */
  193. };
  194.  
  195. /* Entropy decoding */
  196. struct jpeg_entropy_decoder {
  197.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  198.   JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
  199.                 JBLOCKROW *MCU_data));
  200. };
  201.  
  202. /* Inverse DCT (also performs dequantization) */
  203. typedef JMETHOD(void, inverse_DCT_method_ptr,
  204.         (j_decompress_ptr cinfo, jpeg_component_info * compptr,
  205.          JCOEFPTR coef_block,
  206.          JSAMPARRAY output_buf, JDIMENSION output_col));
  207.  
  208. struct jpeg_inverse_dct {
  209.   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
  210.   JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
  211.   /* It is useful to allow each component to have a separate IDCT method. */
  212.   inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
  213. };
  214.  
  215. /* Upsampling (note that upsampler must also call color converter) */
  216. struct jpeg_upsampler {
  217.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  218.   JMETHOD(void, upsample, (j_decompress_ptr cinfo,
  219.                JSAMPIMAGE input_buf,
  220.                JDIMENSION *in_row_group_ctr,
  221.                JDIMENSION in_row_groups_avail,
  222.                JSAMPARRAY output_buf,
  223.                JDIMENSION *out_row_ctr,
  224.                JDIMENSION out_rows_avail));
  225.  
  226.   boolean need_context_rows;    /* TRUE if need rows above & below */
  227. };
  228.  
  229. /* Colorspace conversion */
  230. struct jpeg_color_deconverter {
  231.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  232.   JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
  233.                 JSAMPIMAGE input_buf, JDIMENSION input_row,
  234.                 JSAMPARRAY output_buf, int num_rows));
  235. };
  236.  
  237. /* Color quantization or color precision reduction */
  238. struct jpeg_color_quantizer {
  239.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
  240.   JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
  241.                  JSAMPARRAY input_buf, JSAMPARRAY output_buf,
  242.                  int num_rows));
  243.   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
  244. };
  245.  
  246.  
  247. /* Miscellaneous useful macros */
  248.  
  249. #undef MAX
  250. #define MAX(a,b)    ((a) > (b) ? (a) : (b))
  251. #undef MIN
  252. #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  253.  
  254.  
  255. /* We assume that right shift corresponds to signed division by 2 with
  256.  * rounding towards minus infinity.  This is correct for typical "arithmetic
  257.  * shift" instructions that shift in copies of the sign bit.  But some
  258.  * C compilers implement >> with an unsigned shift.  For these machines you
  259.  * must define RIGHT_SHIFT_IS_UNSIGNED.
  260.  * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
  261.  * It is only applied with constant shift counts.  SHIFT_TEMPS must be
  262.  * included in the variables of any routine using RIGHT_SHIFT.
  263.  */
  264.  
  265. #ifdef RIGHT_SHIFT_IS_UNSIGNED
  266. #define SHIFT_TEMPS    INT32 shift_temp;
  267. #define RIGHT_SHIFT(x,shft)  \
  268.     ((shift_temp = (x)) < 0 ? \
  269.      (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
  270.      (shift_temp >> (shft)))
  271. #else
  272. #define SHIFT_TEMPS
  273. #define RIGHT_SHIFT(x,shft)    ((x) >> (shft))
  274. #endif
  275.  
  276.  
  277. /* Short forms of external names for systems with brain-damaged linkers. */
  278.  
  279. #ifdef NEED_SHORT_EXTERNAL_NAMES
  280. #define jinit_master_compress    jICMaster
  281. #define jinit_c_main_controller    jICMainC
  282. #define jinit_c_prep_controller    jICPrepC
  283. #define jinit_c_coef_controller    jICCoefC
  284. #define jinit_color_converter    jICColor
  285. #define jinit_downsampler    jIDownsampler
  286. #define jinit_forward_dct    jIFDCT
  287. #define jinit_huff_encoder    jIHEncoder
  288. #define jinit_marker_writer    jIMWriter
  289. #define jinit_master_decompress    jIDMaster
  290. #define jinit_d_main_controller    jIDMainC
  291. #define jinit_d_coef_controller    jIDCoefC
  292. #define jinit_d_post_controller    jIDPostC
  293. #define jinit_marker_reader    jIMReader
  294. #define jinit_huff_decoder    jIHDecoder
  295. #define jinit_inverse_dct    jIIDCT
  296. #define jinit_upsampler        jIUpsampler
  297. #define jinit_color_deconverter    jIDColor
  298. #define jinit_1pass_quantizer    jI1Quant
  299. #define jinit_2pass_quantizer    jI2Quant
  300. #define jinit_merged_upsampler    jIMUpsampler
  301. #define jinit_memory_mgr    jIMemMgr
  302. #define jdiv_round_up        jDivRound
  303. #define jround_up        jRound
  304. #define jcopy_sample_rows    jCopySamples
  305. #define jcopy_block_row        jCopyBlocks
  306. #define jzero_far        jZeroFar
  307. #endif /* NEED_SHORT_EXTERNAL_NAMES */
  308.  
  309.  
  310. /* Compression module initialization routines */
  311. EXTERN void jinit_master_compress JPP((j_compress_ptr cinfo));
  312. EXTERN void jinit_c_main_controller JPP((j_compress_ptr cinfo,
  313.                      boolean need_full_buffer));
  314. EXTERN void jinit_c_prep_controller JPP((j_compress_ptr cinfo,
  315.                      boolean need_full_buffer));
  316. EXTERN void jinit_c_coef_controller JPP((j_compress_ptr cinfo,
  317.                      boolean need_full_buffer));
  318. EXTERN void jinit_color_converter JPP((j_compress_ptr cinfo));
  319. EXTERN void jinit_downsampler JPP((j_compress_ptr cinfo));
  320. EXTERN void jinit_forward_dct JPP((j_compress_ptr cinfo));
  321. EXTERN void jinit_huff_encoder JPP((j_compress_ptr cinfo));
  322. EXTERN void jinit_marker_writer JPP((j_compress_ptr cinfo));
  323. /* Decompression module initialization routines */
  324. EXTERN void jinit_master_decompress JPP((j_decompress_ptr cinfo));
  325. EXTERN void jinit_d_main_controller JPP((j_decompress_ptr cinfo,
  326.                      boolean need_full_buffer));
  327. EXTERN void jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
  328.                      boolean need_full_buffer));
  329. EXTERN void jinit_d_post_controller JPP((j_decompress_ptr cinfo,
  330.                      boolean need_full_buffer));
  331. EXTERN void jinit_marker_reader JPP((j_decompress_ptr cinfo));
  332. EXTERN void jinit_huff_decoder JPP((j_decompress_ptr cinfo));
  333. EXTERN void jinit_inverse_dct JPP((j_decompress_ptr cinfo));
  334. EXTERN void jinit_upsampler JPP((j_decompress_ptr cinfo));
  335. EXTERN void jinit_color_deconverter JPP((j_decompress_ptr cinfo));
  336. EXTERN void jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
  337. EXTERN void jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
  338. EXTERN void jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
  339. /* Memory manager initialization */
  340. EXTERN void jinit_memory_mgr JPP((j_common_ptr cinfo));
  341.  
  342. /* Utility routines in jutils.c */
  343. EXTERN long jdiv_round_up JPP((long a, long b));
  344. EXTERN long jround_up JPP((long a, long b));
  345. EXTERN void jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
  346.                    JSAMPARRAY output_array, int dest_row,
  347.                    int num_rows, JDIMENSION num_cols));
  348. EXTERN void jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
  349.                  JDIMENSION num_blocks));
  350. EXTERN void jzero_far JPP((void FAR * target, size_t bytestozero));
  351.  
  352.  
  353. /* Suppress undefined-structure complaints if necessary. */
  354.  
  355. #ifdef INCOMPLETE_TYPES_BROKEN
  356. #ifndef AM_MEMORY_MANAGER    /* only jmemmgr.c defines these */
  357. struct jvirt_sarray_control { long dummy; };
  358. struct jvirt_barray_control { long dummy; };
  359. #endif
  360. #endif /* INCOMPLETE_TYPES_BROKEN */
  361.